#ifndef MODELOPTIMIZER_H
#define MODELOPTIMIZER_H

#include <QObject>
#include <QString>
#include <QProgressDialog>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <assimp/Exporter.hpp>
#include <QThread>

class ModelOptimizer : public QObject
{
    Q_OBJECT

public:
    explicit ModelOptimizer(QObject *parent = nullptr);
    ~ModelOptimizer();

    // 模型优化选项 - 按照UI分组顺序排列
    struct OptimizationOptions {
        // 基础参数
        float vertexReduction;        // 顶点减少比例 (0.0-1.0)
        float normalTolerance;        // 法线容差
        float uvTolerance;           // UV坐标容差
        float globalScale;           // 全局缩放
        
        // 网格优化
        bool removeUnusedVertices;    // 移除未使用的顶点
        bool joinIdenticalVertices;   // 合并相同顶点
        bool optimizeMeshes;          // 优化网格
        bool triangulate;             // 三角化
        bool improveCacheLocality;    // 改善缓存局部性
        bool splitLargeMeshes;       // 分割大网格
        bool preTransformVertices;   // 预变换顶点
        
        // 法线处理
        bool generateNormals;        // 生成法线
        bool generateSmoothNormals;  // 生成平滑法线
        bool forceGenNormals;        // 强制生成法线
        bool dropNormals;            // 丢弃法线
        bool calculateTangentSpace;  // 计算切线空间
        bool fixInfacingNormals;     // 修复内面法线
        bool invertNormals;          // 反转法线
        
        // UV坐标处理
        bool genUVCoords;            // 生成UV坐标
        bool transformUVCoords;      // 变换UV坐标
        bool flipUVs;                // 翻转UV坐标
        
        // 材质优化
        bool removeRedundantMaterials; // 移除冗余材质
        bool embedTextures;          // 嵌入纹理
        
        // 骨骼处理
        bool limitBoneWeights;       // 限制骨骼权重
        bool splitByBoneCount;       // 按骨骼数量分割
        bool debone;                 // 移除骨骼
        
        // 缠绕顺序
        bool flipWindingOrder;       // 翻转缠绕顺序
        bool reverseWindingOrder;    // 反转缠绕顺序
        
        // 数据验证
        bool findDegenerates;         // 查找退化面
        bool findInvalidData;         // 查找无效数据
        bool validateDataStructure;   // 验证数据结构
        bool optimizeGraph;           // 优化场景图
        bool findInstances;          // 查找实例
        
        // 高级选项
        bool sortByPType;             // 按类型排序
        
        // 构造函数，提供默认值 - 按照字段顺序初始化
        OptimizationOptions() :
            // 基础参数
            vertexReduction(0.2f),
            normalTolerance(0.1f),
            uvTolerance(0.01f),
            globalScale(1.0f),
            
            // 网格优化
            removeUnusedVertices(true),
            joinIdenticalVertices(true),
            optimizeMeshes(true),
            triangulate(false),
            improveCacheLocality(false),
            splitLargeMeshes(false),
            preTransformVertices(false),
            
            // 法线处理
            generateNormals(false),
            generateSmoothNormals(false),
            forceGenNormals(false),
            dropNormals(false),
            calculateTangentSpace(false),
            fixInfacingNormals(false),
            invertNormals(false),
            
            // UV坐标处理
            genUVCoords(false),
            transformUVCoords(false),
            flipUVs(false),
            
            // 材质优化
            removeRedundantMaterials(false),
            embedTextures(false),
            
            // 骨骼处理
            limitBoneWeights(false),
            splitByBoneCount(false),
            debone(false),
            
            // 缠绕顺序
            flipWindingOrder(false),
            reverseWindingOrder(false),
            
            // 数据验证
            findDegenerates(false),
            findInvalidData(false),
            validateDataStructure(false),
            optimizeGraph(false),
            findInstances(false),
            
            // 高级选项
            sortByPType(false)
        {}
    };

    // 优化结果信息
    struct OptimizationResult {
        bool success;
        QString errorMessage;
        int originalVertexCount;
        int optimizedVertexCount;
        int originalFaceCount;
        int optimizedFaceCount;
        int originalMaterialCount;
        int optimizedMaterialCount;
        qint64 originalFileSize;
        qint64 optimizedFileSize;
        float compressionRatio;
        
        // 构造函数，提供默认值
        OptimizationResult() :
            success(false),
            originalVertexCount(0),
            optimizedVertexCount(0),
            originalFaceCount(0),
            optimizedFaceCount(0),
            originalMaterialCount(0),
            optimizedMaterialCount(0),
            originalFileSize(0),
            optimizedFileSize(0),
            compressionRatio(0.0f)
        {}
    };

    // 主要优化方法
    void startOptimization(const QString &inputPath, 
                          const QString &outputPath, 
                          const OptimizationOptions &options = OptimizationOptions());
    OptimizationResult getOptimizationResult() const;
    
    // 取消优化
    void cancelOptimization();

signals:
    void progressUpdated(int percentage);
    void optimizationCompleted(const OptimizationResult &result);
    void errorOccurred(const QString &error);

private slots:
    void runOptimization();

private:
    // 辅助方法
    unsigned int getPostProcessFlags(const OptimizationOptions &options);
    void applyMeshOptimization(aiMesh *mesh, const OptimizationOptions &options);
    void removeUnusedVertices(aiMesh *mesh);
    void optimizeVertices(aiMesh *mesh, float reductionRatio);
    void mergeIdenticalVertices(aiMesh *mesh, float tolerance);

    void calculateOptimizationStats(const aiScene *originalScene, 
                                  const aiScene *optimizedScene,
                                  const QString &originalPath,
                                  const QString &optimizedPath,
                                  OptimizationResult &result);
    void updateProgress(int percentage);
    OptimizationResult optimizeModel(const QString &inputPath, 
                                   const QString &outputPath, 
                                   const OptimizationOptions &options);

private:
    Assimp::Importer m_importer;
    Assimp::Exporter m_exporter;
    bool m_cancelRequested;

    // 新增：内存清理辅助函数
    void cleanupSceneMemory(aiScene *scene);
    
    // 新增：场景复制辅助函数
    aiNode* copyNodeTree(const aiNode* sourceNode, aiNode* parent);
    aiMesh* copyMesh(const aiMesh* sourceMesh);
    
    // 新增：内存清理辅助函数
    void cleanupNodeTree(aiNode* node);
    
    // 新增：简化网格函数
    void simplifyMesh(aiMesh *mesh, const OptimizationOptions &options);

    // 新增：纹理嵌入相关函数
    void embedTexturesInScene(aiScene *scene, const QString &modelPath);
    void embedTextureInMaterial(aiMaterial *material, const QString &texturePath, const QString &modelDir);
    bool loadAndEmbedTexture(const QString &texturePath, aiTexture **embeddedTexture);
    QString findTextureFile(const QString &texturePath, const QString &modelDir);
    
    // 新增：验证用户选项的函数
    bool validateOptimizationOptions(const OptimizationOptions &options, QString &warningMessage);

    QThread *m_optimizationThread;
    QString m_inputPath;
    QString m_outputPath;
    OptimizationOptions m_options;
    OptimizationResult m_result;
};

#endif // MODELOPTIMIZER_H 
